package api

import (
	"encoding/json"
	"errors"
	"unsafe"
)

// A转账 : 支持好友和非好友，成功err!=nil，失败返回失败原因
// 响应QQ : 响应QQ
// 支付密码 :
// 对象 : 对方的QQ
// 对象昵称 : 对方的昵称，可随便填
// 金额 : 金额，注意，非好友转账最低1元
// 留言 : 万事顺心
// 非好友转账 : 是否非好友转账，注意，非好友转账最低1元
func A转账(响应QQ int64, 支付密码 string, 对象 int64, 对象昵称, 金额, 留言 string, 非好友转账 bool) error {

	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c对象 := goString2CString(int642Str(对象))
	c对象昵称 := goString2CString(对象昵称)
	c金额 := goString2CString(金额)
	c留言 := goString2CString(留言)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c对象)
		clear(c对象昵称)
		clear(c金额)
		clear(c留言)
	}()

	r, _, _ := api_红包_转账.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c支付密码), cStr2Ptr(c对象), cStr2Ptr(c对象昵称),
		cStr2Ptr(c金额), cStr2Ptr(c留言),
		bool2ptr(非好友转账))

	res := ptr2str(r)
	if res != "success" {
		return errors.New(res)
	}
	return nil
}

// A专享红包 : 仅支持群，成功err!=nil，失败返回失败原因（测试保留接口，切勿过度依赖）
// 响应QQ : 响应QQ
// 支付密码 :
// 群号 :
// 对象 : 对方的QQ
// 数量 :
// 金额 :
// 祝福语 : 恭喜发财
func A专享红包(响应QQ int64, 支付密码 string, 群号, 对象 int64, 数量 int, 金额, 祝福语 string) error {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c群号 := goString2CString(int642Str(群号))
	c对象 := goString2CString(int642Str(对象))
	c数量 := goString2CString(int2Str(数量))
	c金额 := goString2CString(金额)
	c祝福语 := goString2CString(祝福语)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c群号)
		clear(c对象)
		clear(c数量)
		clear(c金额)
		clear(c祝福语)
	}()
	r, _, _ := api_红包_专享红包.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c支付密码), cStr2Ptr(c群号), cStr2Ptr(c对象),
		cStr2Ptr(c数量), cStr2Ptr(c金额),
		cStr2Ptr(c祝福语))
	res := ptr2str(r)
	if res != "success" {
		return errors.New(res)
	}
	return nil
}

// A语音红包 : 成功err!=nil，失败返回失败原因（测试保留接口，切勿过度依赖）
// 响应QQ : 响应QQ
// 支付密码 :
// 对象 : 群发就填群号，私发就填QQ
// 数量 :
// 金额 :
// 口令 :
// 类型 : 1好友;2群;3群临时会话，默认群
func A语音红包(响应QQ int64, 支付密码 string, 对象 int64, 数量 int, 金额, 口令 string, 类型 int) error {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c对象 := goString2CString(int642Str(对象))
	c数量 := goString2CString(int2Str(数量))
	c金额 := goString2CString(金额)
	c口令 := goString2CString(口令)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c对象)
		clear(c数量)
		clear(c金额)
		clear(c口令)
	}()

	r, _, _ := api_红包_语音红包.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c支付密码), cStr2Ptr(c对象), cStr2Ptr(c数量), cStr2Ptr(c金额),
		cStr2Ptr(c口令), uintptr(类型))
	res := ptr2str(r)
	if res != "success" {
		return errors.New(res)
	}
	return nil
}

// A引力球红包 : 该游戏已下线，可以发送，但是无人能领，成功err!=nil，失败返回失败原因（测试保留接口，切勿过度依赖）
// 响应QQ : 响应QQ
// 支付密码 :
// 对象 : 群发就填群号，私发就填QQ
// 数量 :
// 金额 :
// 祝福语 : 恭喜发财
// 类型 : 1好友;2群;3群临时会话，默认群
// 挑战分数 : 必须为正整数，默认100，错误的值强制100
func A引力球红包(响应QQ int64, 支付密码 string, 对象 int64, 数量 int, 金额, 祝福语 string, 类型 int, 挑战分数 int) error {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c对象 := goString2CString(int642Str(对象))
	c数量 := goString2CString(int2Str(数量))
	c挑战分数 := goString2CString(int2Str(挑战分数))
	c金额 := goString2CString(金额)
	c祝福语 := goString2CString(祝福语)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c对象)
		clear(c数量)
		clear(c挑战分数)
		clear(c金额)
		clear(c祝福语)
	}()
	r, _, _ := api_红包_引力球红包.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c支付密码), cStr2Ptr(c对象),
		cStr2Ptr(c数量), cStr2Ptr(c金额),
		cStr2Ptr(c祝福语), uintptr(类型),
		cStr2Ptr(c挑战分数))
	res := ptr2str(r)
	if res != "success" {
		return errors.New(res)
	}
	return nil
}

// A一笔画红包 : 不成功返回失败原因（测试保留接口，切勿过度依赖）
// 响应QQ : 响应QQ
// 支付密码 :
// 群号 :
// 数量 :
// 金额 :
// 关卡 :
func A一笔画红包(响应QQ int64, 支付密码 string, 群号 int64, 数量 int, 金额, 关卡 string) error {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c群号 := goString2CString(int642Str(群号))
	c数量 := goString2CString(int2Str(数量))
	c金额 := goString2CString(金额)
	c关卡 := goString2CString(关卡)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c群号)
		clear(c数量)
		clear(c金额)
		clear(c关卡)
	}()

	r, _, _ := api_红包_一笔画红包.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c支付密码),
		cStr2Ptr(c群号), cStr2Ptr(c数量), cStr2Ptr(c金额), cStr2Ptr(c关卡))
	res := ptr2str(r)
	if res != "success" {
		return errors.New(res)
	}
	return nil
}

// A邀请入群 : 邀请对象入群，频率过快会失败
// 响应QQ : 响应QQ
// 对象QQ : 被邀请人QQ号码（多个号码使用,分割）
// 群号 : 被邀请加入的群号
// 类型 : 0 = 普通  1 = 管理
func A邀请入群(响应QQ int64, 对象QQ, 群号 int64, 类型 int) {

	// var r uintptr
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
		clear(c群号)
	}()

	switch 类型 {
	case 0:
		_, _, _ = api_NoAdminInviteGroup.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
			cStr2Ptr(c对象QQ))
	case 1:
		_, _, _ = api_AdminInviteGroup.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
			cStr2Ptr(c对象QQ))
	default:
		_, _, _ = api_NoAdminInviteGroup.Call(cStr2Ptr(c响应QQ),
			cStr2Ptr(c群号), cStr2Ptr(c对象QQ))
	}

}

// A群礼物抽取 : 抽取群礼物（返回结果Json，需群聊等级LV5后）
// 响应QQ : 响应QQ
func A群礼物抽取(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 群礼物抽取.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A群礼物查询 : 查询我的群礼物（返回json）
// 响应QQ : 响应QQ
func A群礼物查询(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 群礼物查询.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取讨论组列表 : 取得讨论组，#换行符分割
// 响应QQ : 响应QQ
func A取讨论组列表(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取讨论组列表.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取讨论组成员列表 : 取得讨论组成员列表，#换行符分割
// 响应QQ : 响应QQ
// 群号 :
func A取讨论组成员列表(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取讨论组成员列表.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群设置信息 : 包含了常用的群设置信息、全群禁言、自己被禁言、被禁言列表等信息，返回json
// 响应QQ : 响应QQ
// 群号 :
func A取群设置信息(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群设置信息.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群列表_B : QQ群官网接口，返回原始JSON信息
// 响应QQ : 响应QQ
func A取群列表_B(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取群列表_B.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取群列表_A : 协议接口，取得群列表，#换行符分割
// 响应QQ : 响应QQ
func A取群列表_A(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取群列表_A.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取群列表 : QQ空间接口，返回原始JSON信息
// 响应QQ : 响应QQ
func A取群列表(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取群列表.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取群管理Ex : 取包括群主在内的群管列表，返回json，其中oper=1代表接收群验证消息，owner=1代表是群主
// 响应QQ : 响应QQ
// 群号 : 欲取管理员列表群号
func A取群管理Ex(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群管理Ex.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群管理 : 取得群管理，#换行符分割
// 响应QQ : 响应QQ
// 群号 :
func A取群管理(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群管理.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群公告已阅读人员 : 获取群公告已阅读人员详情，成功返回json
// 响应QQ : 响应QQ
// 群号 :
// 公告ID :
// 已读人员 :
func A取群公告已阅读人员(响应QQ, 群号 int64, 公告ID string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c公告ID := goString2CString(公告ID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c公告ID)
	}()
	r, _, _ := 取群公告已阅读人员.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c公告ID))
	return ptr2str(r)
}

// A取群公告 : 取群公告列表，返回json
// 响应QQ : 响应QQ
// 群号 :
func A取群公告(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群公告.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群成员信息 : 取群成员信息，成功返回json
// 响应QQ : 响应QQ
// 群号 :
// 对象QQ :
func A取群成员信息(响应QQ, 群号, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 取群成员信息.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取群成员列表_C : 返回原始JSON信息，（有群员昵称）
// 响应QQ : 响应QQ
// 群号 :
func A取群成员列表_C(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群成员列表_C.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群成员列表_B : 取得群成员列表，#换行符分割（无群员昵称）
// 响应QQ : 响应QQ
// 群号 :
func A取群成员列表_B(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群成员列表_B.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群成员列表 : 群官网方式，比较慢，返回原始JSON信息
// 响应QQ : 响应QQ
// 群号 :
func A取群成员列表(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群成员列表.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取年龄 : 取年龄 成功返回年龄 失败返回-1
// 响应QQ : 响应QQ
// 对象QQ :
func A取年龄(响应QQ, 对象QQ int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取年龄.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2int(r)
}

// A取昵称 : 取对象昵称
// 响应QQ : 响应QQ
// 对象QQ : 欲取得的QQ的号码
func A取昵称(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取昵称.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取某人是否被禁言 : 获取其他人在某个群里是否被禁言，0=没有被禁言，否则为剩余禁言秒数
// 响应QQ : 响应QQ
// 群号 : 欲查询的群号
// 对象QQ : 要查询的对象QQ
func A取某人是否被禁言(响应QQ, 群号, 对象QQ int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 取某人是否被禁言.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c对象QQ))
	return ptr2int(r)
}

// A取名片赞数量 : 取名片赞数量
// 响应QQ : 响应QQ
// 对象QQ :
func A取名片赞数量(响应QQ, 对象QQ int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取名片赞数量.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2int(r)
}

// A取框架日志 : 取框架日志
func A取框架日志() string {
	r, _, _ := 取框架日志.Call()
	return ptr2str(r)
}

// A取框架QQ号 : 取框架QQ号 换行符分割
// 类型 : 0 = 在线QQ  1 = 所有QQ  2 = 离线QQ
func A取框架QQ号(类型 int) string {
	var r uintptr
	switch 类型 {
	case 0:
		r, _, _ = api_GetOnlineQQlist.Call()
	case 1:
		r, _, _ = api_GetQQList.Call()
	case 2:
		r, _, _ = api_GetOffLineList.Call()
	default:
		r, _, _ = api_GetOnlineQQlist.Call()
	}
	return ptr2str(r)
}

// A取机器人状态 : 获取机器人状态信息，成功返回：昵称|帐号|在线状态|速度|收信|发信|在线时间，失败返回空
// 响应QQ : 响应QQ
func A取机器人状态(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取机器人状态.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取机器人屏蔽状态 : 取机器人屏蔽状态，1=正常，0=被屏蔽
// 响应QQ : 响应QQ
func A取机器人屏蔽状态(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取机器人屏蔽状态.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取好友验证方式 : 取对象好友添加验证方式 （00 允许任何人  01 需要身份验证  03 需回答正确问题  04 需回答问题  99 已经是好友）
// 响应QQ : 响应QQ
// 对象QQ : 需获取对象QQ
func A取好友验证方式(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取好友验证方式.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取好友列表_B : 取得好友列表，#换行符分割
// 响应QQ : 响应QQ
func A取好友列表_B(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取好友列表_B.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取好友列表 : 取得好友列表，返回获取到的原始JSON格式信息
// 响应QQ : 响应QQ
func A取好友列表(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取好友列表.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取QQ等级信息 : 获取等级 活跃天数 升级剩余活跃天数，成功返回json
// 响应QQ : 响应QQ
// 对象QQ :
func A取QQ等级信息(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取QQ等级信息.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取P_skey : 取得P_skey
// 响应QQ : 响应QQ
// 类型 : 0=QQ群 1=QQ空间 2=微博 3=腾讯课堂 4=财付通 5=QQ举报 6=QQ信息 7=QQ会员
func A取P_skey(响应QQ int64, 类型 int) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	var r uintptr
	switch 类型 {
	case 0:
		r, _, _ = api_GetGroupPsKey.Call(cStr2Ptr(c响应QQ))
	case 1:
		r, _, _ = api_GetZonePsKey.Call(cStr2Ptr(c响应QQ))
	case 2:
		r, _, _ = api_GetBlogPsKey.Call(cStr2Ptr(c响应QQ))
	case 3:
		r, _, _ = api_GetClassRoomPsKey.Call(cStr2Ptr(c响应QQ))
	case 4:
		r, _, _ = api_GetTenPayPsKey.Call(cStr2Ptr(c响应QQ))
	case 5:
		r, _, _ = api_GetJuBaoPsKey.Call(cStr2Ptr(c响应QQ))
	case 6:
		r, _, _ = api_GetQQInfoPsKey.Call(cStr2Ptr(c响应QQ))
	case 7:
		r, _, _ = api_GetQQVIPPsKey.Call(cStr2Ptr(c响应QQ))
	default:
		return ""
	}
	return ptr2str(r)
}

// A普通红包 : 失败err!=nil
// 响应QQ : 响应QQ
// 支付密码 :
// 对象 : 群发就填群号，私发就填QQ
// 数量 : 个数
// 金额 : 金额
// 祝福语 : 恭喜发财
// 类型 : 1好友;2群;3群临时会话，默认群
// 群号 : 当类型为3时，要提供临时会话的群号
func A普通红包(响应QQ int64, 支付密码 string, 对象 int64, 数量 int, 金额, 祝福语 string, 类型 int, 群号 int64) error {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c对象 := goString2CString(int642Str(对象))
	c数量 := goString2CString(int2Str(数量))
	c金额 := goString2CString(金额)
	c祝福语 := goString2CString(祝福语)
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c对象)
		clear(c数量)
		clear(c金额)
		clear(c祝福语)
		clear(c群号)
	}()
	r, _, _ := api_红包_普通红包.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c支付密码),
		cStr2Ptr(c对象), cStr2Ptr(c数量), cStr2Ptr(c金额), cStr2Ptr(c祝福语),
		uintptr(类型), cStr2Ptr(c群号))
	res := ptr2str(r)
	if res == "success" {
		return nil
	}
	return errors.New(res)
}

// A拼手气红包 : 失败err!=nil
// 响应QQ : 响应QQ
// 支付密码 :
// 对象 : 群发就填群号，私发就填QQ
// 数量 : 个数
// 金额 : 金额
// 祝福语 :
func A拼手气红包(响应QQ int64, 支付密码 string, 对象 int64, 数量 int, 金额, 祝福语 string) error {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c对象 := goString2CString(int642Str(对象))
	c数量 := goString2CString(int2Str(数量))
	c金额 := goString2CString(金额)
	c祝福语 := goString2CString(祝福语)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c对象)
		clear(c数量)
		clear(c金额)
		clear(c祝福语)
	}()
	r, _, _ := api_红包_拼手气红包.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c支付密码),
		cStr2Ptr(c对象), cStr2Ptr(c数量), cStr2Ptr(c金额), cStr2Ptr(c祝福语))
	res := ptr2str(r)
	if res == "success" {
		return nil
	}
	return errors.New(res)
}

// A口令红包 : 失败err!=nil
// 响应QQ : 响应QQ
// 支付密码 :
// 对象 : 群发就填群号，私发就填QQ
// 数量 : 个数
// 金额 : 金额
// 口令 :
// 类型 :  1好友;2群，默认群
func A口令红包(响应QQ int64, 支付密码 string, 对象 int64, 数量 int, 金额, 口令 string, 类型 int) error {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c对象 := goString2CString(int642Str(对象))
	c数量 := goString2CString(int2Str(数量))
	c金额 := goString2CString(金额)
	c口令 := goString2CString(口令)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c对象)
		clear(c数量)
		clear(c金额)
		clear(c口令)
	}()
	r, _, _ := api_红包_口令红包.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c支付密码), cStr2Ptr(c对象),
		cStr2Ptr(c数量), cStr2Ptr(c金额), cStr2Ptr(c口令), uintptr(类型))
	res := ptr2str(r)
	if res == "success" {
		return nil
	}
	return errors.New(res)
}

// A获取照片墙 : 获取照片墙，成功返回json，失败返回空
// 响应QQ : 响应QQ
// 对象QQ : 要获取的对象QQ
func A获取照片墙(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 获取照片墙.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A获取群文件下载直链 : 自行取json中的 "filelink" 字段
// 响应QQ : 响应QQ
// 群号 :
// ID : 文件ID,包括/
// size : 文件尺寸
// name : 文件名称
func A获取群文件下载直链(响应QQ, 群号 int64, ID string, size int, name string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	cID := goString2CString(ID)
	csize := goString2CString(int2Str(size))
	cname := goString2CString(name)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(cID)
		clear(csize)
		clear(cname)
	}()
	r, _, _ := api_GetGroupFileUrl.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		cStr2Ptr(cID), cStr2Ptr(csize), cStr2Ptr(cname))
	return ptr2str(r)
}

// A获取群文件列表 : 获取群文件列表，返回json
// 响应QQ : 响应QQ
// 群号 : 群号
// 文件夹ID : 文件夹ID，包括/，可空，空为根目录
func A获取群文件列表(响应QQ, 群号 int64, 文件夹ID string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c文件夹ID := goString2CString(文件夹ID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c文件夹ID)
	}()
	r, _, _ := api_GetGroupFileList.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c文件夹ID))
	return ptr2str(r)
}

// A红包记录 : 成功返回为json，自行解析，失败返回为原因（测试保留接口，切勿过度依赖）
// 响应QQ : 响应QQ
// 支付密码 :
// 年份 : 留空便为当年年份
// 查询类型 : 1发出红包,2收到红包,默认1
// 第几页 : 默认1,一页10条,第1页最新,收到红包的第1页有总数和总金额
func A红包记录(响应QQ int64, 支付密码, 年份 string, 查询类型 int, 第几页 int) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c年份 := goString2CString(年份)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c年份)
	}()
	r, _, _ := api_红包_红包记录.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c支付密码),
		cStr2Ptr(c年份), uintptr(查询类型), uintptr(第几页))
	return ptr2str(r)
}

// A发送消息 :
// 响应QQ : 响应QQ
// 消息类型 : 1好友 2群 3讨论组 4群临时会话 5讨论组临时会话 6在线临时会话 7好友验证回复会话
// 群号 : 发送群信息、讨论组、群或讨论组临时会话信息时填写，如发送对象为好友或信息类型是0时可空
// 收信QQ : 收信对象QQ，仅在消息类型=1、4、5、6、7时有效，其他可以留空
// 内容 : 信息内容
// 气泡ID : （已失效）默认为0使用本来的气泡，-1为随机气泡
// 匿名 : 0 = 普通  1= 匿名（匿名需要群开启）
// 发送类型 : 0 = 普通文本消息  1 = XML消息  2 = JSON结构消息  3 = HTTP发送模式长消息
func A发送消息(响应QQ int64, 消息类型 int, 群号, 收信QQ int64, 内容 string, 气泡ID, 匿名, 发送类型 int) {

	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c收信QQ := goString2CString(int642Str(收信QQ))
	c内容 := goString2CString(内容)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c收信QQ)
		clear(c内容)
	}()

	if 匿名 >= 1 {
		匿名 = 1
	}

	switch 发送类型 {
	case 0:
		api_SendMsgEx.Call(cStr2Ptr(c响应QQ), uintptr(匿名),
			uintptr(消息类型), cStr2Ptr(c群号), cStr2Ptr(c收信QQ), cStr2Ptr(c内容), uintptr(气泡ID))
	case 1:
		api_SendXml.Call(cStr2Ptr(c响应QQ), uintptr(匿名), uintptr(消息类型),
			cStr2Ptr(c群号), cStr2Ptr(c收信QQ), cStr2Ptr(c内容), uintptr(0))
	case 2:
		api_SendJson.Call(cStr2Ptr(c响应QQ), uintptr(匿名), uintptr(消息类型),
			cStr2Ptr(c群号), cStr2Ptr(c收信QQ), cStr2Ptr(c内容))
	case 3:
		api_SendLongMsg.Call(cStr2Ptr(c响应QQ), uintptr(消息类型),
			cStr2Ptr(c群号), cStr2Ptr(c收信QQ), cStr2Ptr(c内容), uintptr(匿名))
	default:
		api_SendMsgEx.Call(cStr2Ptr(c响应QQ), uintptr(匿名),
			uintptr(消息类型), cStr2Ptr(c群号), cStr2Ptr(c收信QQ), cStr2Ptr(c内容), uintptr(气泡ID))
	}
}

// A点赞 : 调用一次点一下，成功返回空，失败返回理由
// 响应QQ : 响应QQ
// 被赞QQ :
// 类型 : 0 = 最多点赞10次  1 = 最多点赞50次(暂未修复)
func A点赞(响应QQ, 被赞QQ int64, 类型 int) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c被赞QQ := goString2CString(int642Str(被赞QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c被赞QQ)
	}()
	q1 := cStr2Ptr(c响应QQ)
	q2 := cStr2Ptr(c被赞QQ)
	var r uintptr
	if 类型 == 0 {
		r, _, _ = api_UpVote.Call(q1, q2)
	} else {
		r, _, _ = api_UpVoteEx.Call(q1, q2)
	}
	return ptr2str(r)
}

// A查询余额 : 成功返回 D_余额信息指针，失败返回err
// 响应QQ : 响应QQ
// 支付密码 :
func A查询余额(响应QQ int64, 支付密码 string) (*D_余额信息, error) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
	}()
	r, _, _ := api_红包_查询余额.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c支付密码))
	res := ptr2str(r)
	余额信息 := &D_余额信息{}
	if json.Unmarshal([]byte(res), 余额信息) != nil {
		return nil, errors.New(res)
	}
	return 余额信息, nil
}

// AK歌红包 : 成功返回success，失败返回失败原因（测试保留接口，切勿过度依赖）
// 上方为易语言返回。此处废弃。用golang特色-err
// 响应QQ : 响应QQ
// 支付密码 :
// 对象 : 群发就填群号，私发就填QQ
// 数量 : 个数
// 金额 : 金额
// 祝福语 : 恭喜发财
// 类型 : 1好友;2群，默认群
// 歌曲id : 默认124
// 失败原因 : (易语言sdk拿本参数返回失败原因。golang此参数可省略，err!=nil你懂的)
func K歌红包(响应QQ int64, 支付密码 string, 对象 int64, 数量 int, 金额, 祝福语 string, 类型 int, 歌曲id string) error {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c支付密码 := goString2CString(支付密码)
	c对象 := goString2CString(int642Str(对象))
	c数量 := goString2CString(int2Str(数量))
	c金额 := goString2CString(金额)
	c祝福语 := goString2CString(祝福语)
	c歌曲id := goString2CString(歌曲id)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c支付密码)
		clear(c对象)
		clear(c金额)
		clear(c祝福语)
		clear(c歌曲id)
	}()
	r, _, _ := api_红包_K歌红包.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c支付密码),
		cStr2Ptr(c对象), cStr2Ptr(c数量), cStr2Ptr(c金额),
		cStr2Ptr(c祝福语), uintptr(类型),
		cStr2Ptr(c歌曲id))
	res := ptr2str(r)
	if res == "success" {
		return nil
	}
	return errors.New(res)
}

// 请确保bin目录有ffmpeg转码库(框架不自带)，成功返回amr文件完整路径，可直接调用上传语音api，失败返回空
// mp3文件路径
// amr文件路径 :amr文件存放路径
func Mp3ToAmr(mp3文件路径, amr文件路径 string) string {
	// 定义C.char变量
	cmp3文件路径 := goString2CString(mp3文件路径)
	camr文件路径 := goString2CString(amr文件路径)
	//  统一释放
	defer func() {
		clear(cmp3文件路径)
		clear(camr文件路径)
	}()
	r, _, _ := mp3ToAmr.Call(cStr2Ptr(cmp3文件路径), cStr2Ptr(camr文件路径))
	return ptr2str(r)
}

// 用于下载的语音文件转为wav格式，请确保bin目录有ffmpeg转码库(框架不自带)，成功返回wav文件完整路径，失败返回空
// silk文件路径
// wav文件路径 :wav文件存放路径
func SilkToWav(silk文件路径, wav文件路径 string) string {
	// 定义C.char变量
	csilk文件路径 := goString2CString(silk文件路径)
	cwav文件路径 := goString2CString(wav文件路径)
	//  统一释放
	defer func() {
		clear(csilk文件路径)
		clear(cwav文件路径)
	}()
	r, _, _ := silkToWav.Call(cStr2Ptr(csilk文件路径), cStr2Ptr(cwav文件路径))
	return ptr2str(r)
}

// 腾讯Tea加密
// 需加密内容
// 会话KEY :这里填SessionKey
func Tea加密(需加密内容, 会话KEY string) string {
	// 定义C.char变量
	c需加密内容 := goString2CString(需加密内容)
	c会话KEY := goString2CString(会话KEY)
	//  统一释放
	defer func() {
		clear(c需加密内容)
		clear(c会话KEY)
	}()
	r, _, _ := tea加密.Call(cStr2Ptr(c需加密内容), cStr2Ptr(c会话KEY))
	return ptr2str(r)
}

// 腾讯Tea加密
// 需解密内容
// 会话KEY :这里填SessionKey
func Tea解密(需解密内容, 会话KEY string) string {
	// 定义C.char变量
	c需解密内容 := goString2CString(需解密内容)
	c会话KEY := goString2CString(会话KEY)
	//  统一释放
	defer func() {
		clear(c需解密内容)
		clear(c会话KEY)
	}()
	r, _, _ := tea解密.Call(cStr2Ptr(c需解密内容), cStr2Ptr(c会话KEY))
	return ptr2str(r)
}

// WavToAmr :请确保bin目录有ffmpeg转码库(框架不自带)，成功返回amr文件完整路径，可直接调用上传语音api，失败返回空
// wav文件路径
// amr文件路径 :amr文件存放路径
func WavToAmr(wav文件路径, amr文件路径 string) string {
	// 定义C.char变量
	cwav文件路径 := goString2CString(wav文件路径)
	camr文件路径 := goString2CString(amr文件路径)
	//  统一释放
	defer func() {
		clear(cwav文件路径)
		clear(camr文件路径)
	}()
	r, _, _ := wavToAmr.Call(cStr2Ptr(cwav文件路径), cStr2Ptr(camr文件路径))
	return ptr2str(r)
}

// A取是否在线 :查询对象是否在线
// 响应QQ :机器人QQ
// 对象QQ :需获取对象QQ
func A取是否在线(响应QQ, 对象QQ int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取是否在线.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2bool(r)
}

// A查询红包领取详情 :查询群聊红包领取详情，返回json【建议使用查询红包领取详情(Api_HB_DetialEx)，且支持页数】（测试保留接口，切勿过度依赖）
// 响应QQ :收到红包的机器人QQ
// 群号 :收到红包的群号
// mq_msg :{"type":"12","red_id":"900101","key":"96 D5 C0 44 CE","red_Key":"d7a4","red_Skey":"c6a4ecf7","title":"大吉","nick":"鸡丁","p_skey":"LjM*RkjO_"}
func A查询红包领取详情(响应QQ, 群号 int64, mq_msg string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	cmq_msg := goString2CString(mq_msg)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(cmq_msg)
	}()
	r, _, _ := 查询红包领取详情.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(cmq_msg))
	return ptr2str(r)
}

// A查询红包领取详情Ex :查询群聊红包领取详情，返回json（测试保留接口，切勿过度依赖）
// 响应QQ :收到红包的机器人QQ
// 群号 :收到红包的群号
// mq_msg :{"type":"12","red_id":"900101","key":"96 D5 C0 44 CE","red_Key":"d7a4","red_Skey":"c6a4ecf7","title":"大吉","nick":"鸡丁","p_skey":"LjM*RkjO_"}
// 第几页 :每页十条 从第1页开始
func A查询红包领取详情Ex(响应QQ, 群号 int64, mq_msg string, 第几页 int) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	cmq_msg := goString2CString(mq_msg)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(cmq_msg)
	}()
	r, _, _ := 查询红包领取详情Ex.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(cmq_msg), uintptr(第几页))
	return ptr2str(r)
}

// 查询群收钱账单详情，成功返回json，可调用Api_GroupPayIsOk（群收钱账单是否已支付）解析
// 响应QQ
// c_no :发起群收钱获得的c_no
func A查询群收钱账单详情(响应QQ int64, c_no string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	cc_no := goString2CString(c_no)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(cc_no)
	}()
	r, _, _ := 查询群收钱账单详情.Call(cStr2Ptr(c响应QQ), cStr2Ptr(cc_no))
	return ptr2str(r)
}

// A撤回消息 :消息撤回（成功返回空，失败返回腾讯给出的理由）
// 响应QQ
// 群号
// 消息序号 :需撤回消息序号
// 消息ID :需撤回消息ID
func A撤回消息(响应QQ, 群号, 消息序号, 消息ID int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c消息序号 := goString2CString(int642Str(消息序号))
	c消息ID := goString2CString(int642Str(消息ID))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c消息序号)
		clear(c消息ID)
	}()
	r, _, _ := 撤回消息.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		cStr2Ptr(c消息序号), cStr2Ptr(c消息ID))
	return ptr2str(r)
}

//向CleverQQ日志窗口发送一条本插件的日志，可用于调试输出需要的内容，或定位插件错误与运行状态
func A输出日志(msg string) {
	// 定义C.char变量
	cmsg := goString2CString(msg)
	//  统一释放
	defer func() {
		clear(cmsg)
	}()
	_, _, _ = outPutLog.Call(cStr2Ptr(cmsg))
}

// A转发群文件到群 : 转发群文件到指定群，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 来自群 :
// 目标群 :
// 文件ID :
func A转发群文件到群(响应QQ, 来自群, 目标群 int64, 文件ID string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c来自群 := goString2CString(int642Str(来自群))
	c目标群 := goString2CString(int642Str(目标群))
	c文件ID := goString2CString(文件ID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c来自群)
		clear(c目标群)
		clear(c文件ID)
	}()
	r, _, _ := 转发群文件到群.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c来自群),
		cStr2Ptr(c目标群), cStr2Ptr(c文件ID))
	return ptr2bool(r)
}

// A转发群文件到好友 : 转发群文件到指定好友，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 来自群 :
// 目标好友QQ :
// 文件ID :
func A转发群文件到好友(响应QQ, 来自群, 目标好友QQ int64, 文件ID string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c来自群 := goString2CString(int642Str(来自群))
	c目标好友QQ := goString2CString(int642Str(目标好友QQ))
	c文件ID := goString2CString(文件ID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c来自群)
		clear(c目标好友QQ)
		clear(c文件ID)
	}()
	r, _, _ := 转发群文件到好友.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c来自群), cStr2Ptr(c目标好友QQ), cStr2Ptr(c文件ID))
	return ptr2bool(r)
}

// A重载自身 : 重载自身
// path :
func A重载自身(path string) {
	// 定义C.char变量
	cpath := goString2CString(path)
	//  统一释放
	defer func() {
		clear(cpath)
	}()
	重载自身.Call(cStr2Ptr(cpath))
}

// A置移除讨论组成员 : 将对象移除讨论组 成功返回空 失败返回理由
// 响应QQ : 响应QQ
// 讨论组ID : 需执行的讨论组ID
// 对象QQ : 被执行对象
func A置移除讨论组成员(响应QQ, 讨论组ID, 对象QQ int64) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c讨论组ID := goString2CString(int642Str(讨论组ID))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c讨论组ID)
		clear(c对象QQ)
	}()
	置移除讨论组成员.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c讨论组ID), cStr2Ptr(c对象QQ))
}

// A置邀请讨论组 : 邀请对象加入讨论组 成功返回空 失败返回理由
// 响应QQ : 响应QQ
// 讨论组ID : 需执行的讨论组ID
// 邀请对象QQ : 被邀请对象QQ 多个用,分割
func A置邀请讨论组(响应QQ, 讨论组ID, 邀请对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c讨论组ID := goString2CString(int642Str(讨论组ID))
	c邀请对象QQ := goString2CString(int642Str(邀请对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c讨论组ID)
		clear(c邀请对象QQ)
	}()
	r, _, _ := 置邀请讨论组.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c讨论组ID), cStr2Ptr(c邀请对象QQ))
	return ptr2str(r)
}

// A置踢出群成员 : 将对象移除群
// 响应QQ : 响应QQ
// 群号 : 被执行群号
// 对象QQ : 被执行对象
// 不再接收加群请求 : 真为不再接收，假为接收
func A置踢出群成员(响应QQ, 群号, 对象QQ int64, 不再接收加群请求 bool) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	置踢出群成员.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c对象QQ), bool2ptr(不再接收加群请求))
}

// A置讨论组名称 : 修改讨论组名称
// 响应QQ : 响应QQ
// 讨论组ID : 需执行的讨论组ID
// 讨论组名称 : 需修改的名称
func A置讨论组名称(响应QQ, 讨论组ID int64, 讨论组名称 string) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c讨论组ID := goString2CString(int642Str(讨论组ID))
	c讨论组名称 := goString2CString(讨论组名称)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c讨论组ID)
		clear(c讨论组名称)
	}()
	置讨论组名称.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c讨论组ID), cStr2Ptr(c讨论组名称))
}

// A置输入状态 : 置正在输入状态（发送消息后会打断状态）
// 响应QQ : 响应QQ
// 对象QQ : 置正在输入状态接收对象
func A置输入状态(响应QQ, 对象QQ int64) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	置输入状态.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
}

// A置删除好友 : 删除好友 成功返回真 失败返回假
// 响应QQ : 响应QQ
// 对象QQ : 被删除对象
func A置删除好友(响应QQ, 对象QQ int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 置删除好友.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2bool(r)
}

// A置群验证事件 : 处理群验证事件
// 响应QQ : 响应QQ
// data : MQ_原始信
// 处理方式 : 10同意 20拒绝 30或0忽略（#事件处理_）
// 附加信息 : 拒绝时的附加信息
// 拒绝不再接受 : 1为真，慎用
func A置群验证事件(响应QQ int64, data string, 处理方式 int, 附加信息 string, 拒绝不再接受 int) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	cdata := goString2CString(data)
	c附加信息 := goString2CString(附加信息)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(cdata)
		clear(c附加信息)
	}()
	置群验证事件.Call(cStr2Ptr(c响应QQ), cStr2Ptr(cdata), uintptr(处理方式), cStr2Ptr(c附加信息), uintptr(拒绝不再接受))
}

// A置群头像Ex : 上传群头像并设置为主头像，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 群号 :
// 图片 :
func A置群头像Ex(响应QQ, 群号 int64, 图片 []byte) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	首地址 := unsafe.Pointer(&图片[0])
	r, _, _ := 置群头像Ex.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), uintptr(首地址), uintptr(len(图片)))
	return ptr2bool(r)

}

// A置群头像 : 上传群头像并设置为主头像，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 群号 :
// 图片地址 : 本地路径或者网络图片地址
func A置群头像(响应QQ, 群号 int64, 图片地址 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c图片地址 := goString2CString(图片地址)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c图片地址)
	}()
	r, _, _ := 置群头像.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c图片地址))
	return ptr2bool(r)
}

// A置群名片 : 修改对象群名片 成功返回真 失败返回假
// 响应QQ : 响应QQ
// 群号 : 对象所处群号
// 对象QQ : 被修改名片人QQ
// 名片 : 需要修改的名片
func A置群名片(响应QQ, 群号, 对象QQ int64, 名片 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	c名片 := goString2CString(名片)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
		clear(c名片)
	}()
	r, _, _ := 置群名片.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		cStr2Ptr(c对象QQ), cStr2Ptr(c名片))
	return ptr2bool(r)
}

// A置群名称 : 修改群名称，成功返回1，失败返回0
// 响应QQ : 响应QQ
// 群号 :
// 群名 :
func A置群名称(响应QQ, 群号 int64, 群名 string) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c群名 := goString2CString(群名)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c群名)
	}()
	r, _, _ := 置群名称.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c群名))
	return ptr2int(r)
}

// A置群精华消息 : 设置群精华消息（返回结果请调试查看：机器人非管理员，禁止设置精华消息）
// 响应QQ : 响应QQ
// 群号 : 需设置的消息群号
// 消息序号 : 需设置的消息序号
// 消息ID : 需设置的消息ID
func A置群精华消息(响应QQ, 群号, 消息序号, 消息ID int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c消息序号 := goString2CString(int642Str(消息序号))
	c消息ID := goString2CString(int642Str(消息ID))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c消息序号)
		clear(c消息ID)
	}()
	r, _, _ := 置群精华消息.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c消息序号), cStr2Ptr(c消息ID))
	return ptr2str(r)
}

// A置群公告 : 发布群公告（成功返回真，失败返回假），调用此API应保证响应QQ为管理员
// 响应QQ : 响应QQ
// 群号 : 欲发布公告的群号
// 标题 : 公告标题
// 内容 : 公告内容
func A置群公告(响应QQ, 群号 int64, 标题, 内容 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c标题 := goString2CString(标题)
	c内容 := goString2CString(内容)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c标题)
		clear(c内容)
	}()
	r, _, _ := 置群公告.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		cStr2Ptr(c标题), cStr2Ptr(c内容))
	return ptr2bool(r)
}

// A置群成员发起群聊开关 : 置群成员发起群聊开关，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 群号 :
// 开关 : 1=允许，0=禁止
func A置群成员发起群聊开关(响应QQ, 群号 int64, 开关 int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 置群成员发起群聊开关.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), uintptr(开关))
	return ptr2bool(r)
}

// A置群成员发起临时会话开关 : 置群成员发起临时会话开关，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 群号 :
// 开关 : 1=允许，0=禁止
func A置群成员发起临时会话开关(响应QQ, 群号 int64, 开关 int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 置群成员发起临时会话开关.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), uintptr(开关))
	return ptr2bool(r)
}

// A置全群禁言 : 置全群禁言
// 响应QQ : 响应QQ
// 群号 : 欲操作的群号
// 开关 : 1为开启，0为解除
func A置全群禁言(响应QQ, 群号 int64, 开关 int) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 置全群禁言.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), uintptr(开关))
	return ptr2bool(r)
}

// A置屏蔽群消息 : 屏蔽或接收某群消息
// 响应QQ : 响应QQ
// 群号 :
// 类型 : 1接收群消息 2收进群助手且不提醒 3屏蔽群消息 4为接收群消息但不提醒
func A置屏蔽群消息(响应QQ, 群号 int64, 类型 int) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	置屏蔽群消息.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), uintptr(类型))
}

// A置匿名开关 : 开关群匿名消息发送功能    成功返回真  失败返回假
// 响应QQ : 响应QQ
// 群号 : 需开关群匿名功能群号
// 开关 : 真开    假关
func A置匿名开关(响应QQ, 群号 int64, 开关 bool) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 置匿名开关.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), bool2ptr(开关))
	return ptr2bool(r)
}

// A置解除黑名单 : 解除好友黑名单
// 响应QQ : 响应QQ
// 对象QQ :
func A置解除黑名单(响应QQ, 对象QQ int64) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	置解除黑名单.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
}

// A置禁言Ex : 禁言或者解除禁言群内的某人，支持普通和匿名群员，协议方式
// 响应QQ : 响应QQ
// 类型 : 1=普通群员，2=匿名群员
// 群号 : 禁言对象所在群
// 对象 : 类型=1时为QQ，类型=2时为消息头的GUID，例如[Anonymity,name=女巫,flagkey=0496C35647C413FA1EEC562D2276261AE903D7B3A9BE07157EDEB56AE3166CC7CFA313F8A8C98D93]
// 时长 : 禁言时间，0为解除禁言，单位为秒，最长禁言30天
func A置禁言Ex(响应QQ int64, 类型 int, 群号 int64, 对象 string, 时长 int) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象 := goString2CString(对象)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象)
	}()
	r, _, _ := 置禁言Ex.Call(cStr2Ptr(c响应QQ), uintptr(类型),
		cStr2Ptr(c群号), cStr2Ptr(c对象),
		uintptr(时长))
	return ptr2bool(r)
}

// A置禁言 : 群内禁言某人
// 响应QQ : 响应QQ
// 群号 : 欲操作的群号
// 对象QQ : 欲禁言的对象
// 时间 : 禁言时间，0为解除禁言 （单位为秒，最长一个月）
func A置禁言(响应QQ, 群号, 对象QQ int64, 时间 int) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 置禁言.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		cStr2Ptr(c对象QQ), uintptr(时间))
	return ptr2bool(r)
}

// A置拉入黑名单 : 将好友拉入黑名单  成功返回真 失败返回假
// 响应QQ : 响应QQ
// 对象QQ :
func A置拉入黑名单(响应QQ, 对象QQ int64) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	置拉入黑名单.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
}

// A置机器人状态 : 修改机器人在线状态
// 响应QQ : 响应QQ
// 类型 : 1、我在线上 2、Q我吧 3、离开 4、忙碌 5、请勿打扰 6、隐身
// 状态附加信息 :
func A置机器人状态(响应QQ int64, 类型 int, 状态附加信息 string) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c状态附加信息 := goString2CString(状态附加信息)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c状态附加信息)
	}()
	置机器人状态.Call(cStr2Ptr(c响应QQ), uintptr(类型), cStr2Ptr(c状态附加信息))
}

// A置机器人性别 : 修改机器人性别
// 响应QQ : 响应QQ
// 性别 : “1”为男 “2”为女
func A置机器人性别(响应QQ int64, 性别 int) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c性别 := goString2CString(int2Str(性别))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c性别)
	}()
	置机器人性别.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c性别))
}

// A置机器人头像 : 修改机器人头像 成功返回真 失败返回假
// 响应QQ : 响应QQ
// 图片地址 :
func A置机器人头像(响应QQ int64, 图片地址 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c图片地址 := goString2CString(图片地址)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c图片地址)
	}()
	r, _, _ := 置机器人头像.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c图片地址))
	return ptr2bool(r)
}

// A置机器人签名 : 修改机器人签名
// 响应QQ : 响应QQ
// 签名 : 个性签名
func A置机器人签名(响应QQ int64, 签名 string) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c签名 := goString2CString(签名)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c签名)
	}()
	置机器人签名.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c签名))
}

// A置机器人昵称 : 修改机器人昵称
// 响应QQ : 响应QQ
// 昵称 : 需要设置的昵称
func A置机器人昵称(响应QQ int64, 昵称 string) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c昵称 := goString2CString(昵称)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c昵称)
	}()
	置机器人昵称.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c昵称))
}

// A置好友语音上传 : 好友语音上传并发送 （成功返回真 失败返回假）
// 响应QQ : 响应QQ
// 接收QQ : 接收语音人QQ
// 语音文件 : 语音文件路径（AMR Silk编码）
func A置好友语音上传(响应QQ, 接收QQ int64, 语音文件 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c接收QQ := goString2CString(int642Str(接收QQ))
	c语音文件 := goString2CString(语音文件)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c接收QQ)
		clear(c语音文件)
	}()
	r, _, _ := 置好友语音上传.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c接收QQ),
		cStr2Ptr(c语音文件))
	return ptr2bool(r)
}

// A置好友验证事件 : 处理好友验证事件
// 响应QQ : 响应QQ
// 对象QQ : 请求添加好友人QQ
// 处理方式 : 10同意 20拒绝 30或0忽略（#事件处理_）
// 附加信息 : 拒绝添加好友 附加信息
func A置好友验证事件(响应QQ, 对象QQ int64, 处理方式 int, 附加信息 string) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	c附加信息 := goString2CString(附加信息)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
		clear(c附加信息)
	}()
	置好友验证事件.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c对象QQ), uintptr(处理方式), cStr2Ptr(c附加信息))
}

// A置好友验证方式Ex : 修改机器人好友验证方式，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 验证方式 : 1为允许任何人 2为需要验证 3为需要正确回答问题， 4为需要填写问题并由我确认
// 设置问题 : 验证方式=3时填写问题,其他类型可空
// 问题答案 : 验证方式=3时填写问题答案,其他类型可空
// 需回答问题1 : 验证方式=4时必填 个数自由选择 最多三个
// 需回答问题2 : 验证方式=4时选填
// 需回答问题3 : 验证方式=4时选填
func A置好友验证方式Ex(响应QQ int64, 验证方式 int, 设置问题, 问题答案, 需回答问题1, 需回答问题2, 需回答问题3 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c设置问题 := goString2CString(设置问题)
	c问题答案 := goString2CString(问题答案)
	c需回答问题1 := goString2CString(需回答问题1)
	c需回答问题2 := goString2CString(需回答问题2)
	c需回答问题3 := goString2CString(需回答问题3)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c设置问题)
		clear(c问题答案)
		clear(c需回答问题1)
		clear(c需回答问题2)
		clear(c需回答问题3)
	}()
	r, _, _ := 置好友验证方式Ex.Call(cStr2Ptr(c响应QQ),
		uintptr(验证方式), cStr2Ptr(c设置问题), cStr2Ptr(c问题答案),
		cStr2Ptr(c需回答问题1), cStr2Ptr(c需回答问题2), cStr2Ptr(c需回答问题3))
	return ptr2bool(r)
}

// A置好友验证方式 : 修改机器人好友验证方式，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 验证方式 : 1为允许任何人 2为需要验证 3为需要正确回答问题 4为回答问题并审核
// 设置问题 : 当类型为3时填写 问题,其他类型可空
// 问题答案 : 设置的问题答案,其他类型可空
func A置好友验证方式(响应QQ int64, 验证方式 int, 设置问题, 问题答案 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c设置问题 := goString2CString(设置问题)
	c问题答案 := goString2CString(问题答案)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c设置问题)
		clear(c问题答案)
	}()
	r, _, _ := 置好友验证方式.Call(cStr2Ptr(c响应QQ), uintptr(验证方式),
		cStr2Ptr(c设置问题), cStr2Ptr(c问题答案))
	return ptr2bool(r)
}

// A置好友备注 : 修改好友备注姓名
// 响应QQ : 响应QQ
// 对象QQ : 需获取对象好友QQ
// 备注 : 需要修改的备注姓名
func A置好友备注(响应QQ, 对象QQ int64, 备注 string) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	c备注 := goString2CString(备注)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
		clear(c备注)
	}()
	置好友备注.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ), cStr2Ptr(c备注))
}

// A置管理员 : 设置或取消群管理员，成功返回1，失败返回0
// 响应QQ : 响应QQ
// 群号 :
// 对象QQ :
// 操作方式 : 1为设置管理，0为取消管理
func A置管理员(响应QQ, 群号, 对象QQ int64, 操作方式 int) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 置管理员.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		cStr2Ptr(c对象QQ), uintptr(操作方式))
	return ptr2int(r)
}

// A置单项好友 : 删除好友变成单项好友\陌生人 成功返回真 失败返回假
// 响应QQ : 响应QQ
// 对象QQ : 被删除对象
func A置单项好友(响应QQ, 对象QQ int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 置单项好友.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2bool(r)
}

// A移除群机器人 : 成功返回真，失败返回假，可能为频率过快，机器人已不存在等原因
// 响应QQ : 响应QQ
// 群号 : 群号
// 腾讯机器人QQ : 详情见文档
func A移除群机器人(响应QQ, 群号 int64, 腾讯机器人QQ string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c腾讯机器人QQ := goString2CString(腾讯机器人QQ)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c腾讯机器人QQ)
	}()
	r, _, _ := 移除群机器人.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c腾讯机器人QQ))
	return ptr2bool(r)
}

// A邀请别人群成员Ex : 邀请别人群成员加入自己群，多群版,成功返回1，失败返回0
// 响应QQ : 响应QQ
// 目标群号 : 被邀请加入的群号
// 群和QQ : 被邀请人和机器人共同存在的群号，格式为：QQ,群号|QQ,群号|QQ,群号
func A邀请别人群成员Ex(响应QQ, 目标群号 int64, 群和QQ string) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c目标群号 := goString2CString(int642Str(目标群号))
	c群和QQ := goString2CString(群和QQ)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c目标群号)
		clear(c群和QQ)
	}()
	r, _, _ := 邀请别人群成员Ex.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c目标群号), cStr2Ptr(c群和QQ))
	return ptr2int(r)
}

// A邀请别人群成员 : 邀请别人群成员加入自己群,成功返回1，失败返回0
// 响应QQ : 响应QQ
// 目标群号 : 要进入的群的群号
// 所在群号 : 被邀请人和机器人共同存在的群号
// 邀请QQ : 被邀请人的QQ,多个用,分开
func A邀请别人群成员(响应QQ, 目标群号, 所在群号 int64, 邀请QQ string) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c目标群号 := goString2CString(int642Str(目标群号))
	c所在群号 := goString2CString(int642Str(所在群号))
	c邀请QQ := goString2CString(邀请QQ)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c目标群号)
		clear(c所在群号)
		clear(c邀请QQ)
	}()
	r, _, _ := 邀请别人群成员.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c目标群号),
		cStr2Ptr(c所在群号), cStr2Ptr(c邀请QQ))
	return ptr2int(r)
}

// A修改群验证方式 : 修改群验证方式，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 群号 :
// 验证方式 : 1允许任何人 2需验证信息 3回答问题并确认 4正确回答问题 5拒绝进群。
// 设置问题 : 当验证方式为3时填写问题,其他类型可空
// 问题答案 : 当验证方式为3时填写问题答案,其他类型可空
func A修改群验证方式(响应QQ, 群号 int64, 验证方式 int, 设置问题, 问题答案 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c设置问题 := goString2CString(设置问题)
	c问题答案 := goString2CString(问题答案)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c设置问题)
		clear(c问题答案)
	}()
	r, _, _ := 修改群验证方式.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		uintptr(验证方式), cStr2Ptr(c设置问题), cStr2Ptr(c问题答案))
	return ptr2bool(r)
}

// A下线其他设备 : 下线其他在线设备，例如手机QQ、手表QQ、ipadQQ等
// 响应QQ : 响应QQ
// 设备ID : 设备ID，MQ_msg里的DeviceID
// flag : flag
func A下线其他设备(响应QQ int64, 设备ID, flag string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c设备ID := goString2CString(设备ID)
	cflag := goString2CString(flag)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c设备ID)
		clear(cflag)
	}()
	r, _, _ := 下线其他设备.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c设备ID), cStr2Ptr(cflag))
	return ptr2bool(r)
}

// A下线QQ : 令指定QQ下线，应确保QQ号码已在列表中且在线
// 响应QQ : 响应QQ
func A下线QQ(响应QQ int64) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	下线QQ.Call(cStr2Ptr(c响应QQ))
}

// A退群 :
// 响应QQ : 响应QQ
// 群号 :
func A退群(响应QQ, 群号 int64) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	退群.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
}

// A退出讨论组 :
// 响应QQ : 响应QQ
// 讨论组ID :
func A退出讨论组(响应QQ, 讨论组ID int64) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c讨论组ID := goString2CString(int642Str(讨论组ID))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c讨论组ID)
	}()
	退出讨论组.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c讨论组ID))

}

// A添加群机器人 : 成功返回真，失败返回假，可能为频率过快，机器人已存在等原因
// 响应QQ : 响应QQ
// 群号 :
// 腾讯机器人QQ : 详情见文档
func A添加群机器人(响应QQ, 群号 int64, 腾讯机器人QQ string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c腾讯机器人QQ := goString2CString(腾讯机器人QQ)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c腾讯机器人QQ)
	}()
	r, _, _ := 添加群机器人.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		cStr2Ptr(c腾讯机器人QQ))
	return ptr2bool(r)
}

// A添加好友Max : 主动加好友 成功返回1，否则返回失败理由 当对象设置需要正确回答问题、不允许任何人添加、出现短信、滑块时无条件失败
// 响应QQ : 响应QQ
// 对象QQ :
// 附加理由 : 加好友提交的理由
// 群号 : 如果来源=5，那么此项填写群号
// 来源 : 1=来自QQ号查找(默认),2=来自昵称查询,3=来自条件查找,4=来自临时会话,5=来自QQ群,6=来自QQ空间,7=来自拍拍网,8=来自最近联系人,9=来自企业查找,10=来自临时会话,11=来自QQ游戏,12=来自多人聊天,13=来自圈子,14=来自批量导入QQ好友,15=来自附近的人,16=来自好友推荐,17=来自可能认识的人,18=来自QQ查找-有缘人,19=来自QQ查找-打过招呼的人,20=来自闪约,21=来自电视QQ,22=来自QQ好友,23=来自群聊,24=来自组织,25=来自精确查找,26=来自名片分享
func A添加好友Max(响应QQ, 对象QQ int64, 附加理由, 群号 string, 来源 int) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	c附加理由 := goString2CString(附加理由)
	c群号 := goString2CString(群号)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
		clear(c附加理由)
		clear(c群号)
	}()
	r, _, _ := 添加好友Max.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ),
		cStr2Ptr(c附加理由), cStr2Ptr(c群号), uintptr(来源))
	return ptr2str(r)
}

// A添加好友Ex : 主动加好友(主要用于起点号) 成功返回真 失败返回假 当对象设置需要正确回答问题或不允许任何人添加时无条件失败)
// 响应QQ : 响应QQ
// 对象QQ :
// 附加理由 : 加好友提交的理由
func A添加好友Ex(响应QQ, 对象QQ int64, 附加理由 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	c附加理由 := goString2CString(附加理由)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
		clear(c附加理由)
	}()
	r, _, _ := 添加好友Ex.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ), cStr2Ptr(c附加理由))
	return ptr2bool(r)
}

// A添加好友 : 主动加好友 成功返回真 失败返回假 当对象设置需要正确回答问题或不允许任何人添加时无条件失败
// 响应QQ : 响应QQ
// 对象QQ :
// 附加信息 : 添加理由
func A添加好友(响应QQ, 对象QQ int64, 附加信息 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	c附加信息 := goString2CString(附加信息)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
		clear(c附加信息)
	}()
	r, _, _ := 添加好友.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ), cStr2Ptr(c附加信息))
	return ptr2bool(r)
}

// A添加QQ : 向框架帐号列表添加一个登录QQ
// 帐号 : 机器人QQ
// 密码 :
// 令牌 : 可空
// 代理 : 可空，若填写请先勾选[代理保存本地]，并且选择相应的代理类型
func A添加QQ(帐号 int64, 密码, 令牌, 代理 string) bool {
	// 定义C.char变量
	c帐号 := goString2CString(int642Str(帐号))
	c密码 := goString2CString(密码)
	c令牌 := goString2CString(令牌)
	c代理 := goString2CString(代理)
	//  统一释放
	defer func() {
		clear(c帐号)
		clear(c密码)
		clear(c令牌)
		clear(c代理)
	}()
	r, _, _ := 添加QQ.Call(cStr2Ptr(c帐号), cStr2Ptr(c密码),
		cStr2Ptr(c令牌), cStr2Ptr(c代理))
	return ptr2bool(r)
}

// A提交短信验证 : 发送短信后，调用此API查询是否加群成功，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 短信标识 :
func A提交短信验证(响应QQ int64, 短信标识 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c短信标识 := goString2CString(短信标识)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c短信标识)
	}()
	r, _, _ := 提交短信验证.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c短信标识))
	return ptr2bool(r)
}

// A私聊图片GUI转群聊GUID : 私聊图片GUI转群聊GUID，返回示例：[pic={B7187A00-1039-436B-CB80-44B1C436B477}.png]
// 响应QQ : 响应QQ
// 图片GUID : 群里的图片GUID，例如：[pic={363751070-1330166564-B7187A001039436BCB8044B1C436B477}.png]
func A私聊图片GUI转群聊GUID(响应QQ int64, 图片GUID string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c图片GUID := goString2CString(图片GUID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c图片GUID)
	}()
	r, _, _ := 私聊图片GUI转群聊GUID.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c图片GUID))
	return ptr2str(r)
}

// A申请加群Ex : 返回格式为：是否成功=真&失败原因=&短信标识=短信标识，如果短信标识不为空，就是需要短信，调用取短信详情（Api_GetJoinGroupMsg）获取短信详情
// 响应QQ : 响应QQ
// 群号 :
// 理由 :
// 接口 : 接口 0=随机，1=搜索群号、2=附近的群、3=通知界面加群、4=链接加群、5=关键词、6=精确查找
// 通道 : 通道 0=随机，1=新版，2=老版
func A申请加群Ex(响应QQ, 群号 int64, 理由 string, 接口, 通道 int) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c理由 := goString2CString(理由)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c理由)
	}()
	r, _, _ := 申请加群Ex.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c理由), uintptr(接口), uintptr(通道))
	return ptr2str(r)
}

// A申请加群 : 申请加群
// 响应QQ : 响应QQ
// 群号 : 欲申请加入的群号
// 理由 : 附加理由，可留空（需回答正确问题时，请填写问题答案）
func A申请加群(响应QQ, 群号 int64, 理由 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c理由 := goString2CString(理由)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c理由)
	}()
	r, _, _ := 申请加群.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c理由))
	return ptr2bool(r)
}

// A设置特别关心 : 设置特别关心
// 响应QQ : 响应QQ
// 对象QQ :
func A设置特别关心(响应QQ, 对象QQ int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 设置特别关心.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2bool(r)
}

// A上传照片墙 : 上传照片墙，成功返回filekey，可用来删除照片墙，失败返回空
// 响应QQ : 响应QQ
// 图片地址 : 本地图片路径或者网络图片地址
func A上传照片墙(响应QQ int64, 图片地址 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c图片地址 := goString2CString(图片地址)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c图片地址)
	}()
	r, _, _ := 上传照片墙.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c图片地址))
	return ptr2str(r)
}

// A上传语音 : 上传QQ语音，成功返回语音GUID（只能发送群消息使用，不能好友）  失败返回空
// 响应QQ : 响应QQ
// 语音文件 : 语音文件路径（AMR Silk编码）（或者wav文件）
func A上传语音(响应QQ int64, 语音文件 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c语音文件 := goString2CString(语音文件)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c语音文件)
	}()
	r, _, _ := 上传语音.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c语音文件))
	return ptr2str(r)
}

// A上传图片ExNew : 成功返回该图片GUID（格式为[pic={E9A12BBC-A5F9-1074-40D7-D1F229B4CA05}.png]），失败返回空
// 响应QQ : 响应QQ
// 上传类型 : 1好友、临时会话  2群、讨论组 Ps：好友临时会话用类型 1，群讨论组用类型 2；当填写错误时，图片GUID发送不会成功
// 参考对象 : 上传该图片所属的群号或QQ
// 图片 :
func A上传图片ExNew(响应QQ int64, 上传类型 int, 参考对象 int64, 图片 []byte) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c参考对象 := goString2CString(int642Str(参考对象))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c参考对象)
	}()
	首地址 := unsafe.Pointer(&图片[0])
	r, _, _ := 上传图片ExNew.Call(cStr2Ptr(c响应QQ), uintptr(上传类型),
		cStr2Ptr(c参考对象), uintptr(首地址), uintptr(len(图片)))
	return ptr2str(r)
}

// A上传图片 : 上传图片，成功返回该图片GUID（格式为[pic={E9A12BBC-A5F9-1074-40D7-D1F229B4CA05}.png]），失败返回空
// 响应QQ : 响应QQ
// 上传类型 : 1好友、临时会话  2群、讨论组 Ps：好友临时会话用类型 1，群讨论组用类型 2；当填写错误时，图片GUID发送不会成功
// 参考对象 : 上传该图片所属的群号或QQ
// 图片地址 : 本地路径或者网络图片地址
func A上传图片(响应QQ int64, 上传类型 int, 参考对象 int64, 图片地址 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c图片地址 := goString2CString(图片地址)
	c参考对象 := goString2CString(int642Str(参考对象))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c参考对象)
		clear(c图片地址)
	}()
	r, _, _ := 上传图片.Call(cStr2Ptr(c响应QQ), uintptr(上传类型),
		cStr2Ptr(c参考对象), cStr2Ptr(c图片地址))
	return ptr2str(r)
}

// A上传群文件 : 发送群文件，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 目标群号 :
// 本地文件路径 :
func A上传群文件(响应QQ, 目标群号 int64, 本地文件路径 string) bool {

	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c目标群号 := goString2CString(int642Str(目标群号))
	c本地文件路径 := goString2CString(本地文件路径)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c目标群号)
		clear(c本地文件路径)
	}()
	r, _, _ := 上传群文件.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c目标群号),
		cStr2Ptr(c本地文件路径))
	return ptr2bool(r)
}

// A上传好友文件 : 发送好友文件，成功返回1 失败返回0
// 响应QQ : 响应QQ
// 发送QQ :
// 本地文件路径 : 文件名不能太长！
func A上传好友文件(响应QQ, 发送QQ int64, 本地文件路径 string) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c发送QQ := goString2CString(int642Str(发送QQ))
	c本地文件路径 := goString2CString(本地文件路径)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c发送QQ)
		clear(c本地文件路径)
	}()
	r, _, _ := 上传好友文件.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c发送QQ), cStr2Ptr(c本地文件路径))
	return ptr2int(r)
}

// A删除照片墙 : 删除照片墙，成功返回真，失败返回假
// 响应QQ : 响应QQ
// filekey :
func A删除照片墙(响应QQ int64, filekey string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	cfilekey := goString2CString(filekey)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(cfilekey)
	}()
	r, _, _ := 删除照片墙.Call(cStr2Ptr(c响应QQ), cStr2Ptr(cfilekey))
	return ptr2bool(r)
}

// A删除QQ : 删除框架帐号列表内指定QQ，不可在执行登录过程中删除QQ否则有几率引起错误
// QQ号 : 响应QQ
func A删除QQ(QQ号 string) {
	// 定义C.char变量
	cQQ号 := goString2CString(QQ号)
	//  统一释放
	defer func() {
		clear(cQQ号)
	}()
	删除QQ.Call(cStr2Ptr(cQQ号))
}

// A群作业发布 : QQ群作业发布（返回Json格式）
// 响应QQ : 响应QQ
// 群号 :
// 作业名 :
// 标题 :
// 内容 :
func A群作业发布(响应QQ, 群号 int64, 作业名, 标题, 内容 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c作业名 := goString2CString(作业名)
	c标题 := goString2CString(标题)
	c内容 := goString2CString(内容)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c作业名)
		clear(c标题)
		clear(c内容)
	}()
	r, _, _ := 群作业发布.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号),
		cStr2Ptr(c作业名), cStr2Ptr(c标题), cStr2Ptr(c内容))
	return ptr2str(r)
}

// A群收钱账单是否已支付 : 群收钱账单是否已支付，已支付返回1，未支付返回0
// 账单详情json : 查询账单详情获得的json
// 要查询的QQ :
func A群收钱账单是否已支付(账单详情json, 要查询的QQ string) int {
	// 定义C.char变量
	c账单详情json := goString2CString(账单详情json)
	c要查询的QQ := goString2CString(要查询的QQ)
	//  统一释放
	defer func() {
		clear(c账单详情json)
		clear(c要查询的QQ)
	}()
	r, _, _ := 群收钱账单是否已支付.Call(cStr2Ptr(c账单详情json), cStr2Ptr(c要查询的QQ))
	return ptr2int(r)
}

// A群聊图片GUI转私聊GUID : 群聊图片GUI转私聊GUID，返回示例：[pic={363751070-1330166564-B7187A001039436BCB8044B1C436B477}.png]
// 响应QQ : 响应QQ
// 图片GUID : 群里的图片GUID，例如：[pic={B7187A00-1039-436B-CB80-44B1C436B477}.png]
func A群聊图片GUI转私聊GUID(响应QQ int64, 图片GUID string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c图片GUID := goString2CString(图片GUID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c图片GUID)
	}()
	r, _, _ := 群聊图片GUI转私聊GUID.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c图片GUID))
	return ptr2str(r)
}

// A群礼物赠送 : 送群礼物（成功返回真，失败返回假）
// 响应QQ : 响应QQ
// 群号 :
// 对象QQ :
// 礼物ID :
// 赠送数量 :
func A群礼物赠送(响应QQ, 群号, 对象QQ int64, 礼物ID string, 赠送数量 int) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	c礼物ID := goString2CString(礼物ID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
		clear(c礼物ID)
	}()
	r, _, _ := 群礼物赠送.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c对象QQ),
		cStr2Ptr(c礼物ID), uintptr(赠送数量))
	return ptr2bool(r)
}

// A群号转群ID : 群号转群ID
// 群号 :
func A群号转群ID(群号 int64) string {
	// 定义C.char变量
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c群号)
	}()
	r, _, _ := 群号转群ID.Call(cStr2Ptr(c群号))
	return ptr2str(r)
}

// A群ID转群号 : 群ID转群号
// 群ID :
func A群ID转群号(群ID string) string {
	// 定义C.char变量
	c群ID := goString2CString(群ID)
	//  统一释放
	defer func() {
		clear(c群ID)
	}()
	r, _, _ := 群ID转群号.Call(cStr2Ptr(c群ID))
	return ptr2str(r)
}

// A取自己是否被禁言 : 获取自己在某个群里是否被禁言，0=没有被禁言，否则为剩余禁言秒数，如需频繁使用，请调用 取群设置信息(Api_GetGroupSetInfo)，可同时获得全群禁言信息
// 响应QQ : 响应QQ
// 群号 :
func A取自己是否被禁言(响应QQ, 群号 int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取自己是否被禁言.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2int(r)
}

// A取长Ldw : 取得机器人网页操作用参数长Ldw
// 响应QQ : 响应QQ
func A取长Ldw(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取长Ldw.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取长Clientkey : 取得机器人网页操作用的长Clientkey
// 响应QQ : 响应QQ
func A取长Clientkey(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取长Clientkey.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取长Bkn : 取得机器人网页操作用参数长Bkn或长G_tk
// 响应QQ : 响应QQ
func A取长Bkn(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取长Bkn.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取在线状态 : 查询对象在线状态   返回 1、在线 2、Q我 3、离开 4、忙碌 5、勿扰 6、隐身或离线（）
// 响应QQ : 响应QQ
// 对象QQ :
func A取在线状态(响应QQ, 对象QQ int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取在线状态.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2int(r)
}

// A取语音下载地址 : 取语音下载地址，支持好友和群聊语音，下载的文件类型为silk
// 响应QQ : 响应QQ
// 语音GUID : [Voi={xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx}.amr]
func A取语音下载地址(响应QQ int64, 语音GUID string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c语音GUID := goString2CString(语音GUID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c语音GUID)
	}()
	r, _, _ := 取语音下载地址.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c语音GUID))
	return ptr2str(r)
}

// A取邮箱 : 取邮箱，获取对象QQ资料内邮箱栏为邮箱时返回
// 响应QQ : 响应QQ
// 对象QQ :
func A取邮箱(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取邮箱.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取学校 : 取学校，获取对象QQ资料内学校栏
// 响应QQ : 响应QQ
// 对象QQ :
func A取学校(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取学校.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取性别 : 取对象性别 1男 2女  未知或失败返回-1
// 响应QQ : 响应QQ
// 对象QQ :
func A取性别(响应QQ, 对象QQ int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取性别.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2int(r)
}

// A取消特别关心 :
// 响应QQ : 响应QQ
// 对象QQ :
func A取消特别关心(响应QQ, 对象QQ int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取消特别关心.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2bool(r)
}

// A取消设置群精华消息 : 取消设置群精华消息（成功返回空，失败返回腾讯给出的理由）
// 响应QQ : 响应QQ
// 群号 : 需取消设置的消息群号
// 消息序号 : 需取消设置的消息序号
// 消息ID : 需取消设置的消息ID
func A取消设置群精华消息(响应QQ, 群号, 消息序号, 消息ID int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c消息序号 := goString2CString(int642Str(消息序号))
	c消息ID := goString2CString(int642Str(消息ID))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c消息序号)
		clear(c消息ID)
	}()
	r, _, _ := 取消设置群精华消息.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c消息序号), cStr2Ptr(c消息ID))
	return ptr2str(r)
}

// A取消二维码登录 :
// qr_id : 响应QQ
func A取消二维码登录(qr_id string) {
	// 定义C.char变量
	cqr_id := goString2CString(qr_id)
	//  统一释放
	defer func() {
		clear(cqr_id)
	}()
	取消二维码登录.Call(cStr2Ptr(cqr_id))
}

// A取图片下载连接 : 根据图片GUID取得图片下载连接
// 响应QQ : 响应QQ
// 图片类型 : 1 群 讨论组  2临时会话和好友
// 参考对象 : 图片所属对应的群号和好友QQ（可随意乱填写）
// 图片GUID : 例如[pic={xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}.jpg]，支持闪照GUID
func A取图片下载连接(响应QQ int64, 图片类型 int, 参考对象 int64, 图片GUID string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c参考对象 := goString2CString(int642Str(参考对象))
	c图片GUID := goString2CString(图片GUID)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c参考对象)
		clear(c图片GUID)
	}()
	r, _, _ := 取图片下载连接.Call(cStr2Ptr(c响应QQ), uintptr(图片类型),
		cStr2Ptr(c参考对象), cStr2Ptr(c图片GUID))
	return ptr2str(r)
}

// A取搜索群 : 搜索群，返回原始json
// 响应QQ : 响应QQ
// 关键词 :
// 页数 :
func A取搜索群(响应QQ int64, 关键词 string, 页数 int) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c关键词 := goString2CString(关键词)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c关键词)
	}()
	r, _, _ := 取搜索群.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c关键词), uintptr(页数))
	return ptr2str(r)
}

// A取是否支持匿名 : 查询群是否支持匿名聊天,1为支持,0不支持
// 响应QQ : 响应QQ
// 群号 :
func A取是否支持匿名(响应QQ, 群号 int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取是否支持匿名.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2int(r)
}

// A取是否允许群成员发起群聊Ex : 取是否允许群成员发起群聊，稳定版，如需频繁使用，请调用 取群设置信息(Api_GetGroupSetInfo)，可同时获得 是否允许群成员发起临时会话 等其他群设置信息
// 响应QQ : 响应QQ
// 群号 :
func A取是否允许群成员发起群聊Ex(响应QQ, 群号 int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取是否允许群成员发起群聊Ex.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2bool(r)
}

// A取是否允许群成员发起群聊 : 取是否允许群成员发起群聊，允许返回真，禁止返回假
// 响应QQ : 响应QQ
// 群号 :
func A取是否允许群成员发起群聊(响应QQ, 群号 int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取是否允许群成员发起群聊.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2bool(r)
}

// A取是否允许群成员发起临时会话Ex : 取是否允许群成员发起临时会话，稳定版，如需频繁使用，请调用 取群设置信息(Api_GetGroupSetInfo)，可同时获得 是否允许群成员发起群聊 等其他群设置信息
// 响应QQ : 响应QQ
// 群号 :
func A取是否允许群成员发起临时会话Ex(响应QQ, 群号 int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取是否允许群成员发起临时会话Ex.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2bool(r)
}

// A取是否允许群成员发起临时会话 : 取是否允许群成员发起临时会话，允许返回真，禁止返回假
// 响应QQ : 响应QQ
// 群号 :
func A取是否允许群成员发起临时会话(响应QQ, 群号 int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取是否允许群成员发起临时会话.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2bool(r)
}

// A取是否允许临时会话 : 取是否允许在线状态临时会话，支持返回真，不支持返回假（非讨论组和群临时）
// 响应QQ : 响应QQ
// 群号 :
func A取是否允许临时会话(响应QQ, 群号 int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取是否允许临时会话.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2bool(r)
}

// A取生日 : 取出生日期
// 响应QQ : 响应QQ
// 群号 :
func A取生日(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取生日.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群验证方式Ex : 0获取失败 1允许任何人 2需要验证消息 3不允许任何人加群 4需要正确回答问题 5需要回答问题并由管理员审核 6付费群
// 响应QQ : 响应QQ
// 群号 :
func A取群验证方式Ex(响应QQ, 群号 int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群验证方式Ex.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2int(r)
}

// A取群验证方式 : 查询对象群验证方式 1允许任何人 2需要验证消息 3不允许任何人加群 4需要正确回答问题 5需要回答问题并由管理员审核 6付费群 0群号不存在（获取失败返回空）
// 响应QQ : 响应QQ
// 群号 :
func A取群验证方式(响应QQ, 群号 int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群验证方式.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2int(r)
}

// A取群是否全体禁言 : 获取群里否开启了全体禁言，真=开启了，假=未开启，如需频繁使用，请调用 取群设置信息(Api_GetGroupSetInfo)，可同时获得自己被禁言信息
// 响应QQ : 响应QQ
// 群号 :
func A取群是否全体禁言(响应QQ, 群号 int64) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群是否全体禁言.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2bool(r)
}

// A取群人数 : 查询对象群当前人数和上限人数，返回格式为：群人数/群上限
// 响应QQ : 响应QQ
// 群号 :
func A取群人数(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群人数.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群名片 : 取对象群名片
// 响应QQ : 响应QQ
// 群号 :
// 对象QQ : 欲取得群名片的QQ号码
func A取群名片(响应QQ, 群号, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 取群名片.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取群名Ex : 取QQ群名Ex，非群成员也可以查询
// 响应QQ : 响应QQ
// 群号 :
func A取群名Ex(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群名Ex.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群名 : 取QQ群名
// 响应QQ : 响应QQ
// 群号 :
func A取群名(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群名.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取群聊等级 : 查询对象或自身群聊等级（返回实际等级 失败返回空）
// 响应QQ : 响应QQ
// 群号 : 查询群号
// 对象QQ : 需查询对象或机器人QQ
func A取群聊等级(响应QQ, 群号, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 取群聊等级.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取群介绍 : 取QQ群的介绍
// 响应QQ : 响应QQ
// 群号 :
func A取群介绍(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 取群介绍.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A取好友备注 : 取好友备注姓名（成功返回备注，失败或无备注返回空）
// 响应QQ : 响应QQ
// 对象QQ :
func A取好友备注(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取好友备注.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取公司 : 取学校，获取对象QQ资料内学校栏
// 响应QQ : 响应QQ
// 对象QQ :
func A取公司(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取公司.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取个性签名 :
// 响应QQ : 响应QQ
// 对象QQ :
func A取个性签名(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取个性签名.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取个人说明 :
// 响应QQ : 响应QQ
// 对象QQ :
func A取个人说明(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取个人说明.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取短信详情 : 返回json文本 含有需发送至短信号码 短信内容,{"SendMsgNumber":"1888666666","SendMsgToNumber":"1069***794","MsgText":"***"}
// 响应QQ : 响应QQ
// 短信标识 : 短信标识
func A取短信详情(响应QQ int64, 短信标识 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c短信标识 := goString2CString(短信标识)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c短信标识)
	}()
	r, _, _ := 取短信详情.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c短信标识))
	return ptr2str(r)
}

// A取达人天数 : 查询对象或自身QQ达人天数（返回实际天数 失败返回-1）
// 响应QQ : 机器人QQ
// 对象QQ : 需查询对象或机器人QQ
func A取达人天数(响应QQ, 对象QQ int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取达人天数.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2int(r)
}

// A取插件状态 : 取得插件自身启用状态，启用真 禁用假
func A取插件状态() bool {
	r, _, _ := 取插件状态.Call()
	return ptr2bool(r)
}

// A取SessionKey : 获取会话SessionKey密钥
// 响应QQ : 响应QQ
func A取SessionKey(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取SessionKey.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取Q龄 : 取Q龄 成功返回Q龄 失败返回-1
// 响应QQ : 响应QQ
// 对象QQ :
func A取Q龄(响应QQ, 对象QQ int64) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取Q龄.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2int(r)
}

// A取QQ资料 : 获取对象资料 此方式为http，调用时应自行注意控制频率（成功返回JSON格式自行解析）
// 响应QQ : 响应QQ
// 对象QQ :
func A取QQ资料(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取QQ资料.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取QQ等级 : 获取等级，成功返回等级
// 响应QQ : 响应QQ
// 对象QQ :
func A取QQ等级(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 取QQ等级.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A取Cookies : 取得机器人网页操作用的Cookies
// 响应QQ : 响应QQ
func A取Cookies(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取Cookies.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取Clientkey : 取得机器人网页操作用的Clientkey
// 响应QQ : 响应QQ
func A取Clientkey(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取Clientkey.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A取Bkn : 取得机器人网页操作用参数Bkn或G_tk
// 响应QQ : 响应QQ
func A取Bkn(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 取Bkn.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A批量设置个人信息 : 批量设置个人信息
// 响应QQ : 响应QQ
// 昵称 :
// 生日 :
// 职业 :
// 家乡 :
// 所在地 :
// 学校 :
// 公司 :
// 手机 :
// 邮箱 :
// 性别 :
// 血型 :
func A批量设置个人信息(响应QQ int64, 昵称, 生日, 职业, 家乡, 所在地,
	学校, 公司, 手机, 邮箱, 性别, 血型 string) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c昵称 := goString2CString(昵称)
	c生日 := goString2CString(生日)
	c职业 := goString2CString(职业)
	c家乡 := goString2CString(家乡)
	c所在地 := goString2CString(所在地)
	c学校 := goString2CString(学校)
	c公司 := goString2CString(公司)
	c手机 := goString2CString(手机)
	c邮箱 := goString2CString(邮箱)
	c性别 := goString2CString(性别)
	c血型 := goString2CString(血型)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c昵称)
		clear(c生日)
		clear(c职业)
		clear(c家乡)
		clear(c所在地)
		clear(c学校)
		clear(c公司)
		clear(c手机)
		clear(c邮箱)
		clear(c性别)
		clear(c血型)
	}()
	批量设置个人信息.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c昵称),
		cStr2Ptr(c生日), cStr2Ptr(c职业),
		cStr2Ptr(c家乡), cStr2Ptr(c所在地),
		cStr2Ptr(c学校), cStr2Ptr(c公司), cStr2Ptr(c手机),
		cStr2Ptr(c邮箱), cStr2Ptr(c性别), cStr2Ptr(c血型))
}

// A领取红包_群聊红包 : 领取群聊红包，支持普通、手气、口令(不发口令，需要自己发)，返回json：{"code":"200","msg":"ok","money":"1"})，code=200为成功，msg为失败原因money为抢到的金额，单位分（测试保留接口，切勿过度依赖）
// 响应QQ : 收到红包的机器人QQ
// 群号 : 收到红包的群号
// mq_msg : {"type":"12","red_id":"10000320012107063900101419587000","key":"96 D5 C0 44 CE F0 FE E7 9C 32 AF 85 CB 89 80 E8 82 6E 47 C3 40 FA 8C 43 54 0F AD 59 34 CC 0D DE","red_Key":"d7a4d872dd22378ee9148648319aeb6c","red_Skey":"c6a4ecf73599a65a4553c150beac7224","title":"大吉大利","nick":"鸡丁","p_skey":"LjM*RkjOH1fBicw8zs5vp8LID2rp4mP4yLz2xPLoEQw_"}
func A领取红包_群聊红包(响应QQ, 群号 int64, mq_msg string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	cmq_msg := goString2CString(mq_msg)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(cmq_msg)
	}()
	r, _, _ := 领取红包_群聊红包.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(cmq_msg))
	return ptr2str(r)
}

// A领取红包_初始化 : 成功返回真，失败返回假，初始化成功后才可以调用领取红包API（Api_RecHB_Group），建议插件被启用事件下初始化一次就够了，切勿收到红包就初始化，影响速度（测试保留接口，切勿过度依赖）
// key : 这个key不是红包消息里的key，而是开发者专有的key，需要在社区申请成为开发者，即可获得一个key
func A领取红包_初始化(key string) bool {
	// 定义C.char变量
	ckey := goString2CString(key)
	//  统一释放
	defer func() {
		clear(ckey)
	}()
	r, _, _ := 领取红包_初始化.Call(cStr2Ptr(ckey))
	return ptr2bool(r)
}

// A框架版本 :
func A框架版本() string {
	r, _, _ := 框架版本.Call()
	return ptr2str(r)
}

// A禁用插件自身 :
func A禁用插件自身() {
	禁用插件自身.Call()
}

// A计算g_tk : 计算G_tk或者Bkn
// skey或p_skey :
func A计算g_tk(skey或p_skey string) string {
	// 定义C.char变量
	cskey或p_skey := goString2CString(skey或p_skey)
	//  统一释放
	defer func() {
		clear(cskey或p_skey)
	}()
	r, _, _ := 计算g_tk.Call(cStr2Ptr(cskey或p_skey))
	return ptr2str(r)
}

// A获取扫码登录QQ号 :
// qr_id :
func A获取扫码登录QQ号(qr_id string) string {
	// 定义C.char变量
	cqr_id := goString2CString(qr_id)
	//  统一释放
	defer func() {
		clear(cqr_id)
	}()
	r, _, _ := 获取扫码登录QQ号.Call(cStr2Ptr(cqr_id))
	return ptr2str(r)
}

// A获取群管理员操作记录 : 获取指定群的管理员操作记录，返回json
// 响应QQ :
// 目前群号 :
func A获取群管理员操作记录(响应QQ, 目前群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c目前群号 := goString2CString(int642Str(目前群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c目前群号)
	}()
	r, _, _ := 获取群管理员操作记录.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c目前群号))
	return ptr2str(r)
}

// A获取群成员最后发言时间 : 获取群成员最后发言时间，返回10位时间戳
// 响应QQ :
// 群号 :
// 对象QQ :
func A获取群成员最后发言时间(响应QQ, 群号, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 获取群成员最后发言时间.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A获取群成员头衔 : 获取群成员头衔，返回json，如果medalList[0]['medal_desc']=私人订制，无上荣耀，那么medalList[0].name就是专属头衔，如果medalList[0]['medal_desc']=活跃等级，那么medalList[0].name就是活跃头衔
// 响应QQ : 响应QQ
// 群号 :
// 对象QQ :
func A获取群成员头衔(响应QQ, 群号, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 获取群成员头衔.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A获取群成员加群时间 : 获取群成员加群时间，返回10位时间戳
// 响应QQ : 响应QQ
// 群号 :
// 对象QQ :
func A获取群成员加群时间(响应QQ, 群号, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c对象QQ)
	}()
	r, _, _ := 获取群成员加群时间.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A获取群成员分布 : 获取群成员分布，返回格式为：人数|人数|人数|人数
// 响应QQ : 响应QQ
// 群号 :
func A获取群成员分布(响应QQ, 群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
	}()
	r, _, _ := 获取群成员分布.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群号))
	return ptr2str(r)
}

// A获取历史群验证消息 : 返回HTML格式，每页10个，未解析，请自行解析
// 响应QQ : 响应QQ
// seq : 第一页请留空，否则获取下一页时，请填写上一页最后一个seq
func A获取历史群验证消息(响应QQ int64, seq string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	cseq := goString2CString(seq)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(cseq)
	}()
	r, _, _ := 获取历史群验证消息.Call(cStr2Ptr(c响应QQ), cStr2Ptr(cseq))
	return ptr2str(r)
}

// A获取空间访客 : 获取对方空间访客信息，返回json
// 响应QQ : 响应QQ
// 对象QQ :
func A获取空间访客(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 获取空间访客.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A获取加群链接 : 获取指定群的加群链接
// 响应QQ : 响应QQ
// 目前群号 :
func A获取加群链接(响应QQ, 目前群号 int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c目前群号 := goString2CString(int642Str(目前群号))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c目前群号)
	}()
	r, _, _ := 获取加群链接.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c目前群号))
	return ptr2str(r)
}

// A获取封面图片 : 获取对象QQ的封面图片链接
// 响应QQ : 响应QQ
// 对象QQ :
func A获取封面图片(响应QQ, 对象QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c对象QQ := goString2CString(int642Str(对象QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c对象QQ)
	}()
	r, _, _ := 获取封面图片.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c对象QQ))
	return ptr2str(r)
}

// A获取二维码图片路径 : 获取二维码图片的本地路径，返回为：C:\Users\13301\Desktop\开发\MyQQ\MyQQ_Dev\data\cache\1626880321974.png
// qr_file : 响应QQ
func A获取二维码图片路径(qr_file string) string {
	// 定义C.char变量
	cqr_file := goString2CString(qr_file)
	//  统一释放
	defer func() {
		clear(cqr_file)
	}()
	r, _, _ := 获取二维码图片路径.Call(cStr2Ptr(cqr_file))
	return ptr2str(r)
}

// A获取二维码登录状态 : 获取二维码登录状态，返回状态有：1=确认成功，正在登陆|2=登录成功|3=扫描成功，请在手机上点击确认|4=二维码失效，请重新申请|5=未申请二维码|6=等待扫码
// qr_id : 响应QQ
func A获取二维码登录状态(qr_id string) int {
	// 定义C.char变量
	cqr_id := goString2CString(qr_id)
	//  统一释放
	defer func() {
		clear(cqr_id)
	}()
	r, _, _ := 获取二维码登录状态.Call(cStr2Ptr(cqr_id))
	return ptr2int(r)
}

// A获取登录二维码 : 获取登录二维码，成功返回{"status":"200","msg":"用QQ手机版扫描二维码安全登录。","qr_id":"MyQQ-1","qr_file":"1626880321974.png"}
func A获取登录二维码() string {
	r, _, _ := 获取登录二维码.Call()
	return ptr2str(r)
}

// A获取ReleaseNo :
func A获取ReleaseNo() string {
	r, _, _ := 获取ReleaseNo.Call()
	return ptr2str(r)
}

// A获取HttpConnip8080 :
// 响应QQ : 响应QQ
func A获取HttpConnip8080(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 获取HttpConnip8080.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A获取HttpConnip80 :
// 响应QQ : 响应QQ
func A获取HttpConnip80(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 获取HttpConnip80.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A获取HttpConnip443 :
// 响应QQ : 响应QQ
func A获取HttpConnip443(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 获取HttpConnip443.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A获取HttpConn64Token :
// 响应QQ : 响应QQ
func A获取HttpConn64Token(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 获取HttpConn64Token.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A获取HttpConn16Key :
// 响应QQ : 响应QQ
func A获取HttpConn16Key(响应QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	r, _, _ := 获取HttpConn16Key.Call(cStr2Ptr(c响应QQ))
	return ptr2str(r)
}

// A获取ClientVer :
func A获取ClientVer() string {
	r, _, _ := 获取ClientVer.Call()
	return ptr2str(r)
}

// A获取ClientType :
func A获取ClientType() string {
	r, _, _ := 获取ClientType.Call()
	return ptr2str(r)
}

// A关闭群收钱 : 关闭群收钱，成功返回真，失败返回假
// 响应QQ : 响应QQ
// c_no : 发起群收钱获得的c_no
func A关闭群收钱(响应QQ int64, c_no string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	cc_no := goString2CString(c_no)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(cc_no)
	}()
	r, _, _ := 关闭群收钱.Call(cStr2Ptr(c响应QQ), cStr2Ptr(cc_no))
	return ptr2bool(r)
}

// A发送邮件 : 发送邮件，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 收件人昵称 :
// 收件邮箱 :
// 发件人昵称 : 一般是：机器人QQ的昵称
// 发件人邮箱 : 一般是：机器人QQ+@qq.com
// 发送主题 :
// 邮件内容 :
func A发送邮件(响应QQ int64, 收件人昵称, 收件邮箱,
	发件人昵称, 发件人邮箱, 发送主题, 邮件内容 string) bool {
	// 定义C.char变量
	c邮件内容 := goString2CString(邮件内容)
	c响应QQ := goString2CString(int642Str(响应QQ))
	c收件人昵称 := goString2CString(收件人昵称)
	c收件邮箱 := goString2CString(收件邮箱)
	c发件人昵称 := goString2CString(发件人昵称)
	c发件人邮箱 := goString2CString(发件人邮箱)
	c发送主题 := goString2CString(发送主题)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c收件人昵称)
		clear(c收件邮箱)
		clear(c发件人昵称)
		clear(c发件人邮箱)
		clear(c发送主题)
		clear(c邮件内容)
	}()
	r, _, _ := 发送邮件.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c收件人昵称), cStr2Ptr(c收件邮箱),
		cStr2Ptr(c发件人昵称), cStr2Ptr(c发件人邮箱),
		cStr2Ptr(c发送主题), cStr2Ptr(c邮件内容))
	return ptr2bool(r)
}

// A发送群收钱账单催收通知 : 发送群收钱账单催收通知，成功返回1，失败返回0
// 响应QQ : 响应QQ
// c_no : 发起群收钱获得的c_no
func A发送群收钱账单催收通知(响应QQ int64, c_no string) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	cc_no := goString2CString(c_no)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(cc_no)
	}()
	r, _, _ := 发送群收钱账单催收通知.Call(cStr2Ptr(c响应QQ), cStr2Ptr(cc_no))
	return ptr2int(r)
}

// A发送群临时会话文件 : 发送群临时会话文件，成功返回真，失败返回假
// 响应QQ : 响应QQ
// 群号 :
// QQ :
// 本地文件路径 :
func A发送群临时会话文件(响应QQ, 群号, QQ int64, 本地文件路径 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	cQQ := goString2CString(int642Str(QQ))
	c本地文件路径 := goString2CString(本地文件路径)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(cQQ)
		clear(c本地文件路径)
	}()
	r, _, _ := 发送群临时会话文件.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(cQQ), cStr2Ptr(c本地文件路径))
	return ptr2bool(r)
}

// A发送好友语音 : 向下兼容，好友语音上传并发送 （成功返回真 失败返回假）
// 响应QQ : 响应QQ
// 接收QQ : 接收语音人QQ
// 语音文件 : 语音文件路径（AMR Silk编码）
func A发送好友语音(响应QQ, 接收QQ int64, 语音文件 string) bool {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c接收QQ := goString2CString(int642Str(接收QQ))
	c语音文件 := goString2CString(语音文件)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c接收QQ)
		clear(c语音文件)
	}()
	r, _, _ := 发送好友语音.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c接收QQ), cStr2Ptr(c语音文件))
	return ptr2bool(r)
}

// A发送封包 : 向腾讯发送原始封包（成功返回腾讯返回的包 失败返回空）
// 响应QQ : 响应QQ
// 封包 : 封包内容
func A发送封包(响应QQ int64, 封包 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c封包 := goString2CString(封包)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c封包)
	}()
	r, _, _ := 发送封包.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c封包))
	return ptr2str(r)
}

// A发起群投票_多选 : 发起群投票_多选，返回投票fid
// 响应QQ : 响应QQ
// 群号 :
// 标题 :
// 选项1 :
// 选项2 :
// 选项3 :
// 最多选几项 :
// 截止日期十位时间戳 :
// 是否匿名 : 1为匿名 0为不匿名
func A发起群投票_多选(响应QQ, 群号 int64, 标题,
	选项1, 选项2, 选项3, 最多选几项 string,
	截止日期十位时间戳 int64, 是否匿名 int) string {
	// 定义C.char变量
	c最多选几项 := goString2CString(最多选几项)
	c截止日期十位时间戳 := goString2CString(int642Str(截止日期十位时间戳))
	c是否匿名 := goString2CString(int2Str(是否匿名))
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c标题 := goString2CString(标题)
	c选项1 := goString2CString(选项1)
	c选项2 := goString2CString(选项2)
	c选项3 := goString2CString(选项3)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c标题)
		clear(c选项1)
		clear(c选项2)
		clear(c选项3)
		clear(c最多选几项)
		clear(c截止日期十位时间戳)
		clear(c是否匿名)
	}()
	r, _, _ := 发起群投票_多选.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c标题), cStr2Ptr(c选项1),
		cStr2Ptr(c选项2), cStr2Ptr(c选项3),
		cStr2Ptr(c最多选几项), cStr2Ptr(c截止日期十位时间戳), cStr2Ptr(c是否匿名))
	return ptr2str(r)
}

// A发起群投票_单选 : 发起群投票_单选，返回投票fid
// 响应QQ : 响应QQ
// 群号 :
// 标题 :
// 选项1 :
// 选项2 :
// 选项3 :
// 截止日期十位时间戳 :
// 是否匿名 : 1为匿名 0为不匿名
func A发起群投票_单选(响应QQ, 群号 int64, 标题, 选项1,
	选项2, 选项3 string, 截止日期十位时间戳 int64, 是否匿名 int) string {
	// 定义C.char变量
	c截止日期十位时间戳 := goString2CString(int642Str(截止日期十位时间戳))
	c是否匿名 := goString2CString(int2Str(是否匿名))
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c标题 := goString2CString(标题)
	c选项1 := goString2CString(选项1)
	c选项2 := goString2CString(选项2)
	c选项3 := goString2CString(选项3)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c标题)
		clear(c选项1)
		clear(c选项2)
		clear(c选项3)
		clear(c截止日期十位时间戳)
		clear(c是否匿名)
	}()
	r, _, _ := 发起群投票_单选.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c标题), cStr2Ptr(c选项1),
		cStr2Ptr(c选项2), cStr2Ptr(c选项3),
		cStr2Ptr(c截止日期十位时间戳), cStr2Ptr(c是否匿名))
	return ptr2str(r)
}

// A创建群聊 :成功返回群号等信息{"ec":0,"errcode":0,"em":"","gu":914856344,"gc":914856344}，http模式创建群聊，请注意调用频率
// 响应QQ :
// 群名称 :
// 群类别 : 如：10048=行业交流 | IT/互联网 10018=兴趣爱好
func A创建群聊(响应QQ int64, 群名称, 群类别 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群名称 := goString2CString(群名称)
	c群类别 := goString2CString(群类别)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群名称)
		clear(c群类别)
	}()
	r, _, _ := 创建群聊.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c群名称), cStr2Ptr(c群类别))
	return ptr2str(r)
}

// A创建群聊_B : 选人创建群，成功返回群号，请注意调用频率
// 响应QQ :
// 要选的人的QQ : 多个用,隔开，注意是英文逗号
func A创建群聊_B(响应QQ int64, 要选的人的QQ string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c要选的人的QQ := goString2CString(要选的人的QQ)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c要选的人的QQ)
	}()
	r, _, _ := 创建群聊_B.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c要选的人的QQ))
	return ptr2str(r)
}

// A创建讨论组 :
// 响应QQ :
// 讨论组名称 :
func A创建讨论组(响应QQ int64, 讨论组名称 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c讨论组名称 := goString2CString(讨论组名称)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c讨论组名称)
	}()
	r, _, _ := 创建讨论组.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c讨论组名称))
	return ptr2str(r)
}

// A戳一戳 :
// 响应QQ :
// 接收QQ :
//  :
//  :
func A戳一戳(响应QQ, 接收QQ int64) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c接收QQ := goString2CString(int642Str(接收QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c接收QQ)
	}()
	r, _, _ := 戳一戳.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c接收QQ))
	return ptr2str(r)
}

// A登录QQ : 登录指定QQ，应确保QQ号码在列表中已存在
// 响应QQ :
func A登录QQ(响应QQ int64) {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	//  统一释放
	defer func() {
		clear(c响应QQ)
	}()
	登录QQ.Call(cStr2Ptr(c响应QQ))
}

// A发表说说 : 发表说说，成功返回1，失败返回0
// 响应QQ : 机器人QQ
// 说说内容 :
func A发表说说(响应QQ int64, 说说内容 string) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c说说内容 := goString2CString(说说内容)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c说说内容)
	}()
	r, _, _ := 发表说说.Call(cStr2Ptr(c响应QQ), cStr2Ptr(c说说内容))
	return ptr2int(r)
}

// A发表说说_带图 : 发表说说，带一张图片的，成功返回1，失败返回0
// 响应QQ :
// 说说内容 :
// 图片地址 : 本地路径或者网络图片地址
func A发表说说_带图(响应QQ int64, 说说内容, 图片地址 string) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c说说内容 := goString2CString(说说内容)
	c图片地址 := goString2CString(图片地址)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c说说内容)
		clear(c图片地址)
	}()
	r, _, _ := 发表说说_带图.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c说说内容), cStr2Ptr(c图片地址))
	return ptr2int(r)
}

// A发表说说_带图_多图 : 发表说说，带多张图片的，建议9张以下，成功返回1，失败返回0
// 响应QQ :
// 说说内容 :
// 图片地址 : 仅支持本地图片，多个用|分割
func A发表说说_带图_多图(响应QQ int64, 说说内容, 图片地址 string) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c说说内容 := goString2CString(说说内容)
	c图片地址 := goString2CString(图片地址)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c说说内容)
		clear(c图片地址)
	}()
	r, _, _ := 发表说说_带图_多图.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c说说内容), cStr2Ptr(c图片地址))
	return ptr2int(r)
}

// A发表说说_带图Ex : 发表说说，带一张图片的，成功返回1，失败返回0
// 响应QQ :
// 说说内容 :
// 图片 :
func A发表说说_带图Ex(响应QQ int64, 说说内容 string, 图片 []byte) int {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c说说内容 := goString2CString(说说内容)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c说说内容)
	}()
	首地址 := unsafe.Pointer(&图片[0])
	r, _, _ := 发表说说_带图Ex.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c说说内容), uintptr(首地址), uintptr(len(图片)))
	return ptr2int(r)
}

// A发起群收钱 : 成功返回c_no，失败返回：retmsg=账号未实名认证（可通过寻找文本retmsg判断是否成功）
// 响应QQ : 响应QQ
// 群号 :
// 标题 :
// 类型 : 1=均摊，2=指定
// 需支付QQ : 多个用,隔开
// 需支付金额 : 单位分，多人用,隔开，需要和上一个参数保持一致(均摊情况下，每个人的要一样)
func A发起群收钱(响应QQ, 群号 int64, 标题 string, 类型 int, 需支付QQ, 需支付金额 string) string {
	// 定义C.char变量
	c响应QQ := goString2CString(int642Str(响应QQ))
	c群号 := goString2CString(int642Str(群号))
	c标题 := goString2CString(标题)
	c需支付QQ := goString2CString(需支付QQ)
	c需支付金额 := goString2CString(需支付金额)
	//  统一释放
	defer func() {
		clear(c响应QQ)
		clear(c群号)
		clear(c标题)
		clear(c需支付QQ)
		clear(c需支付金额)
	}()
	r, _, _ := 发起群收钱.Call(cStr2Ptr(c响应QQ),
		cStr2Ptr(c群号), cStr2Ptr(c标题), uintptr(类型),
		cStr2Ptr(c需支付QQ), cStr2Ptr(c需支付金额))
	return ptr2str(r)
}
